
/**
 * This is a generated class and is not intended for modification.  
 */
package com.model.valueObjects
{
import com.adobe.fiber.styles.IStyle;
import com.adobe.fiber.styles.Style;
import com.adobe.fiber.styles.StyleValidator;
import com.adobe.fiber.valueobjects.AbstractEntityMetadata;
import com.adobe.fiber.valueobjects.AvailablePropertyIterator;
import com.adobe.fiber.valueobjects.IPropertyIterator;
import mx.events.ValidationResultEvent;
import com.adobe.fiber.core.model_internal;
import com.adobe.fiber.valueobjects.IModelType;
import mx.events.PropertyChangeEvent;

use namespace model_internal;

[ExcludeClass]
internal class _VoEnquiryEmailEntityMetadata extends com.adobe.fiber.valueobjects.AbstractEntityMetadata
{
    private static var emptyArray:Array = new Array();

    model_internal static var allProperties:Array = new Array("quantityEmail", "enq_noEmail", "pro_nameEmail", "remarksEmail", "stamp_noEmail", "other_part_noEmail", "supplierEmail", "prat_noEmail", "baseRemarksEmail");
    model_internal static var allAssociationProperties:Array = new Array();
    model_internal static var allRequiredProperties:Array = new Array("quantityEmail", "enq_noEmail", "pro_nameEmail", "remarksEmail", "stamp_noEmail", "other_part_noEmail", "supplierEmail", "prat_noEmail", "baseRemarksEmail");
    model_internal static var allAlwaysAvailableProperties:Array = new Array("quantityEmail", "enq_noEmail", "pro_nameEmail", "remarksEmail", "stamp_noEmail", "other_part_noEmail", "supplierEmail", "prat_noEmail", "baseRemarksEmail");
    model_internal static var guardedProperties:Array = new Array();
    model_internal static var dataProperties:Array = new Array("quantityEmail", "enq_noEmail", "pro_nameEmail", "remarksEmail", "stamp_noEmail", "other_part_noEmail", "supplierEmail", "prat_noEmail", "baseRemarksEmail");
    model_internal static var derivedProperties:Array = new Array();
    model_internal static var collectionProperties:Array = new Array("quantityEmail", "pro_nameEmail", "remarksEmail", "stamp_noEmail", "other_part_noEmail", "supplierEmail", "prat_noEmail");
    model_internal static var collectionBaseMap:Object;
    model_internal static var entityName:String = "VoEnquiryEmail";
    model_internal static var dependentsOnMap:Object;
    model_internal static var dependedOnServices:Array = new Array();

    
    model_internal var _quantityEmailIsValid:Boolean;
    model_internal var _quantityEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _quantityEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _quantityEmailValidationFailureMessages:Array;
    
    model_internal var _enq_noEmailIsValid:Boolean;
    model_internal var _enq_noEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _enq_noEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _enq_noEmailValidationFailureMessages:Array;
    
    model_internal var _pro_nameEmailIsValid:Boolean;
    model_internal var _pro_nameEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _pro_nameEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _pro_nameEmailValidationFailureMessages:Array;
    
    model_internal var _remarksEmailIsValid:Boolean;
    model_internal var _remarksEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _remarksEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _remarksEmailValidationFailureMessages:Array;
    
    model_internal var _stamp_noEmailIsValid:Boolean;
    model_internal var _stamp_noEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _stamp_noEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _stamp_noEmailValidationFailureMessages:Array;
    
    model_internal var _other_part_noEmailIsValid:Boolean;
    model_internal var _other_part_noEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _other_part_noEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _other_part_noEmailValidationFailureMessages:Array;
    
    model_internal var _supplierEmailIsValid:Boolean;
    model_internal var _supplierEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _supplierEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _supplierEmailValidationFailureMessages:Array;
    
    model_internal var _prat_noEmailIsValid:Boolean;
    model_internal var _prat_noEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _prat_noEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _prat_noEmailValidationFailureMessages:Array;
    
    model_internal var _baseRemarksEmailIsValid:Boolean;
    model_internal var _baseRemarksEmailValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _baseRemarksEmailIsValidCacheInitialized:Boolean = false;
    model_internal var _baseRemarksEmailValidationFailureMessages:Array;

    model_internal var _instance:_Super_VoEnquiryEmail;
    model_internal static var _nullStyle:com.adobe.fiber.styles.Style = new com.adobe.fiber.styles.Style();

    public function _VoEnquiryEmailEntityMetadata(value : _Super_VoEnquiryEmail)
    {
        // initialize property maps
        if (model_internal::dependentsOnMap == null)
        {
            // depenents map
            model_internal::dependentsOnMap = new Object();
            model_internal::dependentsOnMap["quantityEmail"] = new Array();
            model_internal::dependentsOnMap["enq_noEmail"] = new Array();
            model_internal::dependentsOnMap["pro_nameEmail"] = new Array();
            model_internal::dependentsOnMap["remarksEmail"] = new Array();
            model_internal::dependentsOnMap["stamp_noEmail"] = new Array();
            model_internal::dependentsOnMap["other_part_noEmail"] = new Array();
            model_internal::dependentsOnMap["supplierEmail"] = new Array();
            model_internal::dependentsOnMap["prat_noEmail"] = new Array();
            model_internal::dependentsOnMap["baseRemarksEmail"] = new Array();

            // collection base map
            model_internal::collectionBaseMap = new Object()
            model_internal::collectionBaseMap["quantityEmail"] = "String";
            model_internal::collectionBaseMap["pro_nameEmail"] = "String";
            model_internal::collectionBaseMap["remarksEmail"] = "String";
            model_internal::collectionBaseMap["stamp_noEmail"] = "String";
            model_internal::collectionBaseMap["other_part_noEmail"] = "String";
            model_internal::collectionBaseMap["supplierEmail"] = "String";
            model_internal::collectionBaseMap["prat_noEmail"] = "String";
        }

        model_internal::_instance = value;
        model_internal::_quantityEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForQuantityEmail);
        model_internal::_quantityEmailValidator.required = true;
        model_internal::_quantityEmailValidator.requiredFieldError = "quantityEmail is required";
        //model_internal::_quantityEmailValidator.source = model_internal::_instance;
        //model_internal::_quantityEmailValidator.property = "quantityEmail";
        model_internal::_enq_noEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForEnq_noEmail);
        model_internal::_enq_noEmailValidator.required = true;
        model_internal::_enq_noEmailValidator.requiredFieldError = "enq_noEmail is required";
        //model_internal::_enq_noEmailValidator.source = model_internal::_instance;
        //model_internal::_enq_noEmailValidator.property = "enq_noEmail";
        model_internal::_pro_nameEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForPro_nameEmail);
        model_internal::_pro_nameEmailValidator.required = true;
        model_internal::_pro_nameEmailValidator.requiredFieldError = "pro_nameEmail is required";
        //model_internal::_pro_nameEmailValidator.source = model_internal::_instance;
        //model_internal::_pro_nameEmailValidator.property = "pro_nameEmail";
        model_internal::_remarksEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForRemarksEmail);
        model_internal::_remarksEmailValidator.required = true;
        model_internal::_remarksEmailValidator.requiredFieldError = "remarksEmail is required";
        //model_internal::_remarksEmailValidator.source = model_internal::_instance;
        //model_internal::_remarksEmailValidator.property = "remarksEmail";
        model_internal::_stamp_noEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForStamp_noEmail);
        model_internal::_stamp_noEmailValidator.required = true;
        model_internal::_stamp_noEmailValidator.requiredFieldError = "stamp_noEmail is required";
        //model_internal::_stamp_noEmailValidator.source = model_internal::_instance;
        //model_internal::_stamp_noEmailValidator.property = "stamp_noEmail";
        model_internal::_other_part_noEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForOther_part_noEmail);
        model_internal::_other_part_noEmailValidator.required = true;
        model_internal::_other_part_noEmailValidator.requiredFieldError = "other_part_noEmail is required";
        //model_internal::_other_part_noEmailValidator.source = model_internal::_instance;
        //model_internal::_other_part_noEmailValidator.property = "other_part_noEmail";
        model_internal::_supplierEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForSupplierEmail);
        model_internal::_supplierEmailValidator.required = true;
        model_internal::_supplierEmailValidator.requiredFieldError = "supplierEmail is required";
        //model_internal::_supplierEmailValidator.source = model_internal::_instance;
        //model_internal::_supplierEmailValidator.property = "supplierEmail";
        model_internal::_prat_noEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForPrat_noEmail);
        model_internal::_prat_noEmailValidator.required = true;
        model_internal::_prat_noEmailValidator.requiredFieldError = "prat_noEmail is required";
        //model_internal::_prat_noEmailValidator.source = model_internal::_instance;
        //model_internal::_prat_noEmailValidator.property = "prat_noEmail";
        model_internal::_baseRemarksEmailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForBaseRemarksEmail);
        model_internal::_baseRemarksEmailValidator.required = true;
        model_internal::_baseRemarksEmailValidator.requiredFieldError = "baseRemarksEmail is required";
        //model_internal::_baseRemarksEmailValidator.source = model_internal::_instance;
        //model_internal::_baseRemarksEmailValidator.property = "baseRemarksEmail";
    }

    override public function getEntityName():String
    {
        return model_internal::entityName;
    }

    override public function getProperties():Array
    {
        return model_internal::allProperties;
    }

    override public function getAssociationProperties():Array
    {
        return model_internal::allAssociationProperties;
    }

    override public function getRequiredProperties():Array
    {
         return model_internal::allRequiredProperties;   
    }

    override public function getDataProperties():Array
    {
        return model_internal::dataProperties;
    }

    override public function getGuardedProperties():Array
    {
        return model_internal::guardedProperties;
    }

    override public function getUnguardedProperties():Array
    {
        return model_internal::allAlwaysAvailableProperties;
    }

    override public function getDependants(propertyName:String):Array
    {
       if (model_internal::dataProperties.indexOf(propertyName) == -1)
            throw new Error(propertyName + " is not a data property of entity VoEnquiryEmail");  
            
       return model_internal::dependentsOnMap[propertyName] as Array;  
    }

    override public function getDependedOnServices():Array
    {
        return model_internal::dependedOnServices;
    }

    override public function getCollectionProperties():Array
    {
        return model_internal::collectionProperties;
    }

    override public function getCollectionBase(propertyName:String):String
    {
        if (model_internal::collectionProperties.indexOf(propertyName) == -1)
            throw new Error(propertyName + " is not a collection property of entity VoEnquiryEmail");  

        return model_internal::collectionBaseMap[propertyName];
    }

    override public function getAvailableProperties():com.adobe.fiber.valueobjects.IPropertyIterator
    {
        return new com.adobe.fiber.valueobjects.AvailablePropertyIterator(this);
    }

    override public function getValue(propertyName:String):*
    {
        if (model_internal::allProperties.indexOf(propertyName) == -1)
        {
            throw new Error(propertyName + " does not exist for entity VoEnquiryEmail");
        }

        return model_internal::_instance[propertyName];
    }

    override public function setValue(propertyName:String, value:*):void
    {
        if (model_internal::dataProperties.indexOf(propertyName) == -1)
        {
            throw new Error(propertyName + " is not a data property of entity VoEnquiryEmail");
        }

        model_internal::_instance[propertyName] = value;
    }

    override public function getMappedByProperty(associationProperty:String):String
    {
        switch(associationProperty)
        {
            default:
            {
                return null;
            }
        }
    }

    override public function getPropertyLength(propertyName:String):int
    {
        switch(propertyName)
        {
            default:
            {
                return 0;
            }
        }
    }

    override public function isAvailable(propertyName:String):Boolean
    {
        if (model_internal::allProperties.indexOf(propertyName) == -1)
        {
            throw new Error(propertyName + " does not exist for entity VoEnquiryEmail");
        }

        if (model_internal::allAlwaysAvailableProperties.indexOf(propertyName) != -1)
        {
            return true;
        }

        switch(propertyName)
        {
            default:
            {
                return true;
            }
        }
    }

    override public function getIdentityMap():Object
    {
        var returnMap:Object = new Object();

        return returnMap;
    }

    [Bindable(event="propertyChange")]
    override public function get invalidConstraints():Array
    {
        if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
        {
            return model_internal::_instance.model_internal::_invalidConstraints;
        }
        else
        {
            // recalculate isValid
            model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
            return model_internal::_instance.model_internal::_invalidConstraints;        
        }
    }

    [Bindable(event="propertyChange")]
    override public function get validationFailureMessages():Array
    {
        if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
        {
            return model_internal::_instance.model_internal::_validationFailureMessages;
        }
        else
        {
            // recalculate isValid
            model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
            return model_internal::_instance.model_internal::_validationFailureMessages;
        }
    }

    override public function getDependantInvalidConstraints(propertyName:String):Array
    {
        var dependants:Array = getDependants(propertyName);
        if (dependants.length == 0)
        {
            return emptyArray;
        }

        var currentlyInvalid:Array = invalidConstraints;
        if (currentlyInvalid.length == 0)
        {
            return emptyArray;
        }

        var filterFunc:Function = function(element:*, index:int, arr:Array):Boolean
        {
            return dependants.indexOf(element) > -1;
        }

        return currentlyInvalid.filter(filterFunc);
    }

    /**
     * isValid
     */
    [Bindable(event="propertyChange")] 
    public function get isValid() : Boolean
    {
        if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
        {
            return model_internal::_instance.model_internal::_isValid;
        }
        else
        {
            // recalculate isValid
            model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
            return model_internal::_instance.model_internal::_isValid;
        }
    }

    [Bindable(event="propertyChange")]
    public function get isQuantityEmailAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isEnq_noEmailAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isPro_nameEmailAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isRemarksEmailAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isStamp_noEmailAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isOther_part_noEmailAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isSupplierEmailAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isPrat_noEmailAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isBaseRemarksEmailAvailable():Boolean
    {
        return true;
    }


    /**
     * derived property recalculation
     */
    public function invalidateDependentOnQuantityEmail():void
    {
        if (model_internal::_quantityEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfQuantityEmail = null;
            model_internal::calculateQuantityEmailIsValid();
        }
    }
    public function invalidateDependentOnEnq_noEmail():void
    {
        if (model_internal::_enq_noEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfEnq_noEmail = null;
            model_internal::calculateEnq_noEmailIsValid();
        }
    }
    public function invalidateDependentOnPro_nameEmail():void
    {
        if (model_internal::_pro_nameEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfPro_nameEmail = null;
            model_internal::calculatePro_nameEmailIsValid();
        }
    }
    public function invalidateDependentOnRemarksEmail():void
    {
        if (model_internal::_remarksEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfRemarksEmail = null;
            model_internal::calculateRemarksEmailIsValid();
        }
    }
    public function invalidateDependentOnStamp_noEmail():void
    {
        if (model_internal::_stamp_noEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfStamp_noEmail = null;
            model_internal::calculateStamp_noEmailIsValid();
        }
    }
    public function invalidateDependentOnOther_part_noEmail():void
    {
        if (model_internal::_other_part_noEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfOther_part_noEmail = null;
            model_internal::calculateOther_part_noEmailIsValid();
        }
    }
    public function invalidateDependentOnSupplierEmail():void
    {
        if (model_internal::_supplierEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfSupplierEmail = null;
            model_internal::calculateSupplierEmailIsValid();
        }
    }
    public function invalidateDependentOnPrat_noEmail():void
    {
        if (model_internal::_prat_noEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfPrat_noEmail = null;
            model_internal::calculatePrat_noEmailIsValid();
        }
    }
    public function invalidateDependentOnBaseRemarksEmail():void
    {
        if (model_internal::_baseRemarksEmailIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfBaseRemarksEmail = null;
            model_internal::calculateBaseRemarksEmailIsValid();
        }
    }

    model_internal function fireChangeEvent(propertyName:String, oldValue:Object, newValue:Object):void
    {
        this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, propertyName, oldValue, newValue));
    }

    [Bindable(event="propertyChange")]   
    public function get quantityEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get quantityEmailValidator() : StyleValidator
    {
        return model_internal::_quantityEmailValidator;
    }

    model_internal function set _quantityEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_quantityEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_quantityEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "quantityEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get quantityEmailIsValid():Boolean
    {
        if (!model_internal::_quantityEmailIsValidCacheInitialized)
        {
            model_internal::calculateQuantityEmailIsValid();
        }

        return model_internal::_quantityEmailIsValid;
    }

    model_internal function calculateQuantityEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_quantityEmailValidator.validate(model_internal::_instance.quantityEmail)
        model_internal::_quantityEmailIsValid_der = (valRes.results == null);
        model_internal::_quantityEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::quantityEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::quantityEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get quantityEmailValidationFailureMessages():Array
    {
        if (model_internal::_quantityEmailValidationFailureMessages == null)
            model_internal::calculateQuantityEmailIsValid();

        return _quantityEmailValidationFailureMessages;
    }

    model_internal function set quantityEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_quantityEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_quantityEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "quantityEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get enq_noEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get enq_noEmailValidator() : StyleValidator
    {
        return model_internal::_enq_noEmailValidator;
    }

    model_internal function set _enq_noEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_enq_noEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_enq_noEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "enq_noEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get enq_noEmailIsValid():Boolean
    {
        if (!model_internal::_enq_noEmailIsValidCacheInitialized)
        {
            model_internal::calculateEnq_noEmailIsValid();
        }

        return model_internal::_enq_noEmailIsValid;
    }

    model_internal function calculateEnq_noEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_enq_noEmailValidator.validate(model_internal::_instance.enq_noEmail)
        model_internal::_enq_noEmailIsValid_der = (valRes.results == null);
        model_internal::_enq_noEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::enq_noEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::enq_noEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get enq_noEmailValidationFailureMessages():Array
    {
        if (model_internal::_enq_noEmailValidationFailureMessages == null)
            model_internal::calculateEnq_noEmailIsValid();

        return _enq_noEmailValidationFailureMessages;
    }

    model_internal function set enq_noEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_enq_noEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_enq_noEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "enq_noEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get pro_nameEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get pro_nameEmailValidator() : StyleValidator
    {
        return model_internal::_pro_nameEmailValidator;
    }

    model_internal function set _pro_nameEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_pro_nameEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_pro_nameEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "pro_nameEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get pro_nameEmailIsValid():Boolean
    {
        if (!model_internal::_pro_nameEmailIsValidCacheInitialized)
        {
            model_internal::calculatePro_nameEmailIsValid();
        }

        return model_internal::_pro_nameEmailIsValid;
    }

    model_internal function calculatePro_nameEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_pro_nameEmailValidator.validate(model_internal::_instance.pro_nameEmail)
        model_internal::_pro_nameEmailIsValid_der = (valRes.results == null);
        model_internal::_pro_nameEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::pro_nameEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::pro_nameEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get pro_nameEmailValidationFailureMessages():Array
    {
        if (model_internal::_pro_nameEmailValidationFailureMessages == null)
            model_internal::calculatePro_nameEmailIsValid();

        return _pro_nameEmailValidationFailureMessages;
    }

    model_internal function set pro_nameEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_pro_nameEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_pro_nameEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "pro_nameEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get remarksEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get remarksEmailValidator() : StyleValidator
    {
        return model_internal::_remarksEmailValidator;
    }

    model_internal function set _remarksEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_remarksEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_remarksEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "remarksEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get remarksEmailIsValid():Boolean
    {
        if (!model_internal::_remarksEmailIsValidCacheInitialized)
        {
            model_internal::calculateRemarksEmailIsValid();
        }

        return model_internal::_remarksEmailIsValid;
    }

    model_internal function calculateRemarksEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_remarksEmailValidator.validate(model_internal::_instance.remarksEmail)
        model_internal::_remarksEmailIsValid_der = (valRes.results == null);
        model_internal::_remarksEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::remarksEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::remarksEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get remarksEmailValidationFailureMessages():Array
    {
        if (model_internal::_remarksEmailValidationFailureMessages == null)
            model_internal::calculateRemarksEmailIsValid();

        return _remarksEmailValidationFailureMessages;
    }

    model_internal function set remarksEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_remarksEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_remarksEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "remarksEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get stamp_noEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get stamp_noEmailValidator() : StyleValidator
    {
        return model_internal::_stamp_noEmailValidator;
    }

    model_internal function set _stamp_noEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_stamp_noEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_stamp_noEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "stamp_noEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get stamp_noEmailIsValid():Boolean
    {
        if (!model_internal::_stamp_noEmailIsValidCacheInitialized)
        {
            model_internal::calculateStamp_noEmailIsValid();
        }

        return model_internal::_stamp_noEmailIsValid;
    }

    model_internal function calculateStamp_noEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_stamp_noEmailValidator.validate(model_internal::_instance.stamp_noEmail)
        model_internal::_stamp_noEmailIsValid_der = (valRes.results == null);
        model_internal::_stamp_noEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::stamp_noEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::stamp_noEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get stamp_noEmailValidationFailureMessages():Array
    {
        if (model_internal::_stamp_noEmailValidationFailureMessages == null)
            model_internal::calculateStamp_noEmailIsValid();

        return _stamp_noEmailValidationFailureMessages;
    }

    model_internal function set stamp_noEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_stamp_noEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_stamp_noEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "stamp_noEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get other_part_noEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get other_part_noEmailValidator() : StyleValidator
    {
        return model_internal::_other_part_noEmailValidator;
    }

    model_internal function set _other_part_noEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_other_part_noEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_other_part_noEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "other_part_noEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get other_part_noEmailIsValid():Boolean
    {
        if (!model_internal::_other_part_noEmailIsValidCacheInitialized)
        {
            model_internal::calculateOther_part_noEmailIsValid();
        }

        return model_internal::_other_part_noEmailIsValid;
    }

    model_internal function calculateOther_part_noEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_other_part_noEmailValidator.validate(model_internal::_instance.other_part_noEmail)
        model_internal::_other_part_noEmailIsValid_der = (valRes.results == null);
        model_internal::_other_part_noEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::other_part_noEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::other_part_noEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get other_part_noEmailValidationFailureMessages():Array
    {
        if (model_internal::_other_part_noEmailValidationFailureMessages == null)
            model_internal::calculateOther_part_noEmailIsValid();

        return _other_part_noEmailValidationFailureMessages;
    }

    model_internal function set other_part_noEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_other_part_noEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_other_part_noEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "other_part_noEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get supplierEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get supplierEmailValidator() : StyleValidator
    {
        return model_internal::_supplierEmailValidator;
    }

    model_internal function set _supplierEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_supplierEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_supplierEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "supplierEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get supplierEmailIsValid():Boolean
    {
        if (!model_internal::_supplierEmailIsValidCacheInitialized)
        {
            model_internal::calculateSupplierEmailIsValid();
        }

        return model_internal::_supplierEmailIsValid;
    }

    model_internal function calculateSupplierEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_supplierEmailValidator.validate(model_internal::_instance.supplierEmail)
        model_internal::_supplierEmailIsValid_der = (valRes.results == null);
        model_internal::_supplierEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::supplierEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::supplierEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get supplierEmailValidationFailureMessages():Array
    {
        if (model_internal::_supplierEmailValidationFailureMessages == null)
            model_internal::calculateSupplierEmailIsValid();

        return _supplierEmailValidationFailureMessages;
    }

    model_internal function set supplierEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_supplierEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_supplierEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "supplierEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get prat_noEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get prat_noEmailValidator() : StyleValidator
    {
        return model_internal::_prat_noEmailValidator;
    }

    model_internal function set _prat_noEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_prat_noEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_prat_noEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "prat_noEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get prat_noEmailIsValid():Boolean
    {
        if (!model_internal::_prat_noEmailIsValidCacheInitialized)
        {
            model_internal::calculatePrat_noEmailIsValid();
        }

        return model_internal::_prat_noEmailIsValid;
    }

    model_internal function calculatePrat_noEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_prat_noEmailValidator.validate(model_internal::_instance.prat_noEmail)
        model_internal::_prat_noEmailIsValid_der = (valRes.results == null);
        model_internal::_prat_noEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::prat_noEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::prat_noEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get prat_noEmailValidationFailureMessages():Array
    {
        if (model_internal::_prat_noEmailValidationFailureMessages == null)
            model_internal::calculatePrat_noEmailIsValid();

        return _prat_noEmailValidationFailureMessages;
    }

    model_internal function set prat_noEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_prat_noEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_prat_noEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "prat_noEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get baseRemarksEmailStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get baseRemarksEmailValidator() : StyleValidator
    {
        return model_internal::_baseRemarksEmailValidator;
    }

    model_internal function set _baseRemarksEmailIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_baseRemarksEmailIsValid;         
        if (oldValue !== value)
        {
            model_internal::_baseRemarksEmailIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "baseRemarksEmailIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get baseRemarksEmailIsValid():Boolean
    {
        if (!model_internal::_baseRemarksEmailIsValidCacheInitialized)
        {
            model_internal::calculateBaseRemarksEmailIsValid();
        }

        return model_internal::_baseRemarksEmailIsValid;
    }

    model_internal function calculateBaseRemarksEmailIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_baseRemarksEmailValidator.validate(model_internal::_instance.baseRemarksEmail)
        model_internal::_baseRemarksEmailIsValid_der = (valRes.results == null);
        model_internal::_baseRemarksEmailIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::baseRemarksEmailValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::baseRemarksEmailValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get baseRemarksEmailValidationFailureMessages():Array
    {
        if (model_internal::_baseRemarksEmailValidationFailureMessages == null)
            model_internal::calculateBaseRemarksEmailIsValid();

        return _baseRemarksEmailValidationFailureMessages;
    }

    model_internal function set baseRemarksEmailValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_baseRemarksEmailValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_baseRemarksEmailValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "baseRemarksEmailValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }


     /**
     * 
     * @inheritDoc 
     */ 
     override public function getStyle(propertyName:String):com.adobe.fiber.styles.IStyle
     {
         switch(propertyName)
         {
            default:
            {
                return null;
            }
         }
     }
     
     /**
     * 
     * @inheritDoc 
     *  
     */  
     override public function getPropertyValidationFailureMessages(propertyName:String):Array
     {
         switch(propertyName)
         {
            case("quantityEmail"):
            {
                return quantityEmailValidationFailureMessages;
            }
            case("enq_noEmail"):
            {
                return enq_noEmailValidationFailureMessages;
            }
            case("pro_nameEmail"):
            {
                return pro_nameEmailValidationFailureMessages;
            }
            case("remarksEmail"):
            {
                return remarksEmailValidationFailureMessages;
            }
            case("stamp_noEmail"):
            {
                return stamp_noEmailValidationFailureMessages;
            }
            case("other_part_noEmail"):
            {
                return other_part_noEmailValidationFailureMessages;
            }
            case("supplierEmail"):
            {
                return supplierEmailValidationFailureMessages;
            }
            case("prat_noEmail"):
            {
                return prat_noEmailValidationFailureMessages;
            }
            case("baseRemarksEmail"):
            {
                return baseRemarksEmailValidationFailureMessages;
            }
            default:
            {
                return emptyArray;
            }
         }
     }

}

}
